home *** CD-ROM | disk | FTP | other *** search
/ Hyper Stacks 1994 May / Hyper Stacks (Pacific HiTech)(1994)[Mac].iso / Telecom / HyperGCG / hp2pictXCMD.c < prev    next >
Text File  |  1990-05-15  |  11KB  |  465 lines

  1. /* hp2pictXCMD.c
  2.  *
  3.  *
  4.  * Copyright 1990 by d.g.gilbert.
  5.  * dogStar Software && Indiana University Biology Dept.
  6.  * email: gilbertd@iubio.bio.indiana.edu
  7.  *
  8.  * Language: MPW-C 3.0 
  9.  *
  10.  * based in part on AuxWindow by Roger Brown, Dartmouth XCMD's 
  11.  *
  12.  */
  13.  
  14. /* Creates a floating, no go-away window with a picture that is 
  15.      translated from HPGL graphics script 
  16.      
  17.              Card syntax is:
  18.  
  19.     hp2pict "Open", name, [rect]   -- open blank window
  20.             * returns window pointer as The Result
  21.              
  22.     hp2pict "DrawF", window pointer, FILE w/ HPGL
  23.     hp2pict "DrawC", window pointer, CONTAINER w/ HPGL
  24.                     -- draw hp contents to window
  25.  
  26.     hp2pict "Fetch", window pointer, Container w/ (partial) HPGL 
  27.                 -- draw hp while reading it from comm link thru 
  28.                     callback to HyperCard, using HC function "recvTo(,,,)"
  29.             
  30.     hp2pict "File",window pointer,filename -- save pict as file
  31.             
  32.     hp2pict "Clip",window pointer   -- put window pict into clipbd
  33.             
  34.     hp2pict "Print",window pointer     -- print window pict
  35.             
  36.     hp2pict "Close",window pointer     -- close & dispose of window
  37.     
  38. */
  39.  
  40. /*-------- Makefile
  41.  
  42. C -b hp2pictXCMD.c -mbg off
  43. Link -w -rt XCMD=10003 ∂
  44.     -m ENTRYPOINT ∂
  45.     -sg hp2pict ∂
  46.     hp2pictXCMD.c.o ∂
  47.     "{Libraries}HyperXLib.o" ∂
  48.     "{Libraries}Interface.o" ∂
  49.     "{CLibraries}StdCLib.o" ∂
  50.     "{Clibraries}"CSANELib.o ∂
  51.     "{Clibraries}"Cinterface.o ∂
  52.     "{CLibraries}CRuntime.o" ∂
  53.     -o "HyperGCG" 
  54. #-------------------------*/
  55.  
  56.  
  57.  
  58. /*#include <CType.h>*/
  59. #include <Types.h>
  60. #include <StdIO.h>
  61. #include <Sane.h>
  62. #include <QuickDraw.h>
  63. #include <FixMath.h>
  64. #include <Fonts.h> 
  65. #include <Memory.h>
  66. #include <Scrap.h>
  67. #include <OSEvents.h>
  68. #include <OSUtils.h>
  69. #include <Files.h>
  70. #include <Resources.h>
  71. #include <Windows.h>
  72. #include <Events.h>
  73. #include <ToolUtils.h>
  74. #include <Dialogs.h>
  75. #include <PrintTraps.h>
  76. #include <HyperXCmd.h>
  77.  
  78.     /* draw formats */
  79. #define    DFILE        1
  80. #define    DCARD        2
  81. #define    DCOMM        3
  82.  
  83. void  returnValue(XCmdPtr pXCmd, char *theResult);
  84. void    upcase(char *s);
  85. void    OpenHPWind(XCmdPtr pXCmd);
  86. void     DrawHPWind(XCmdPtr pXCmd, int format);
  87. void    FileHPWind(XCmdPtr pXCmd);
  88. void    ClipHPWind(XCmdPtr pXCmd);
  89. void    PrintHPWind(XCmdPtr pXCmd);
  90. void    CloseHPWind(XCmdPtr pXCmd);
  91.  
  92.  
  93. /* XCMD entry -- MUST BE FIRST CODE IN SEG */
  94.  
  95. pascal void EntryPoint(XCmdPtr pXCmd)
  96. {
  97.     Ptr              theMessage;
  98.     char             message[32];
  99.     GrafPtr        cardport;
  100.     
  101.     GetPort( &cardport);
  102.     theMessage = *(pXCmd->params[0]);
  103.     strcpy(message,theMessage);
  104.     upcase(message);
  105.     pXCmd->inArgs[0] = (long) cardport; /* global for subs */
  106.     
  107.     if (strcmp(message,"OPEN")==0)                 OpenHPWind(pXCmd);
  108.     else if (strcmp(message,"DRAWF")==0)     DrawHPWind(pXCmd, DFILE);
  109.     else if (strcmp(message,"DRAWC")==0)     DrawHPWind(pXCmd, DCARD);
  110.     else if (strcmp(message,"FETCH")==0)     DrawHPWind(pXCmd, DCOMM);
  111.     else if (strcmp(message,"FILE")==0)     FileHPWind(pXCmd);
  112.     else if (strcmp(message,"CLIP")==0)     ClipHPWind(pXCmd);
  113.     else if (strcmp(message,"PRINT")==0)     PrintHPWind(pXCmd);
  114.     else if (strcmp(message,"CLOSE")==0)     CloseHPWind(pXCmd);
  115.     else {         
  116.         SysBeep(0);
  117.         returnValue( pXCmd, "Undefined message in hp2pict XCMD");
  118.         }   
  119.     SetPort( cardport);
  120.     return;
  121. }
  122.  
  123.  
  124. #define    min(a,b)    (a<b) ? a : b
  125. #define    max(a,b)    (a>b) ? a : b
  126. #define    Isalpha(c)        ((c >= 'A' & c <= 'Z') \
  127.                                         |  (c >= 'a' & c <= 'z'))
  128.  
  129. int Toupper(char c)
  130. {
  131.     return( (c>='a')&&(c<='z') ? (c-('a'-'A')) : c );
  132. }
  133.  
  134.  
  135. void upcase(char *s)
  136. {
  137.     int i,l;
  138.     l = strlen(s);
  139.     for (i=0;i<l;i++) s[i] = Toupper(s[i]);
  140. }
  141.  
  142. float  Strtod(char *s, char **ends)
  143. {  /* stdlib strtod, strtol use %GlobalData !! */
  144.     float        x;
  145.     short        e;
  146.     decimal    drec;
  147.     short        valid;
  148.     
  149.     e = 0;
  150.     str2dec( s, &e, &drec, &valid);
  151.     x = dec2num( &drec);
  152.     *ends = s + e;
  153.     return x;
  154. }
  155.  
  156.  
  157. void    str2rect(char *c, Rect *r)  
  158. /* convert HC rect string to Rect */
  159. {    
  160.     r->left     = Strtod( c, &c); c++;
  161.     r->top         = Strtod( c, &c); c++;
  162.     r->right     = Strtod( c, &c);    c++;
  163.     r->bottom = Strtod( c, &c);
  164. }
  165.  
  166.  
  167. Boolean hasColorQD(void)
  168. {
  169.     SysEnvRec theWorld;
  170.     int             err;
  171.     
  172.     err = SysEnvirons(1,&theWorld);
  173.     if (err!=0) return false;
  174.     else return theWorld.hasColorQD;
  175. }
  176.  
  177. #define lotsOfColor(wind) \
  178.         ( (**((CGrafPtr)wind)->portPixMap).pixelSize > 7 ) 
  179.             
  180.                 
  181. void  returnValue(XCmdPtr pXCmd, char *theResult)
  182. {
  183.     long len;
  184.     Handle resultHandle;
  185.     
  186.     /* return the result to HCard */
  187.     len = 1+strlen(theResult);
  188.     resultHandle = NewHandle(len);
  189.     HLock(resultHandle);
  190.     BlockMove(theResult,*resultHandle,len);
  191.     HUnlock(resultHandle);
  192.     pXCmd->returnValue = resultHandle;
  193. }    
  194.  
  195.  
  196.  
  197. void OpenHPWind(XCmdPtr pXCmd)
  198. {
  199.     char             *theName, *c, theResult[256];
  200.     Rect             wr;
  201.     Boolean        hascolor;
  202.     WindowPtr myWind;    
  203.     
  204.     theName = *(pXCmd->params[1]);
  205.     hascolor = hasColorQD();
  206.     c = *(pXCmd->params[2]);
  207.     if ((c != NULL) && (*c != 0)) {
  208.         str2rect( c, &wr);
  209.     LocalToGlobal( (Point *)&wr.top);
  210.     LocalToGlobal( (Point *)&wr.bottom);
  211.         }
  212.     else
  213.         SetRect( &wr, 10, 80, 446, 370);    /* scaled size for 9" SE monitor */
  214.     
  215.     /*?? use wStorage == newhandle/movehhi instead of newwindow ptr */
  216.     if (hascolor)  
  217.       myWind = newcwindow( NULL, &wr, theName, true, 
  218.                                 noGrowDocProc, (WindowPtr)-1, false, 0);
  219.     else  
  220.       myWind = newwindow( NULL, &wr, theName, true, 
  221.                                 noGrowDocProc, (WindowPtr)-1, false, 0);
  222.     SetPort(myWind);
  223.     
  224.     numtostring( myWind,theResult);
  225.     returnValue( pXCmd, theResult);
  226.     ShowWindow( myWind);
  227.     BringToFront( myWind);
  228.     SetWRefCon( myWind, 0L);
  229.     SetWindowPic( myWind, NULL);
  230. }
  231.  
  232.  
  233. void CloseHPWind(XCmdPtr pXCmd)
  234. {
  235.     char *theWindowPtr;
  236.     WindowPtr myWind;    
  237.     PicHandle cardPic, pagePic;
  238.     
  239.     theWindowPtr = *(pXCmd->params[1]);
  240.     stringtonum(theWindowPtr,&myWind);
  241.     cardPic = GetWindowPic(myWind);
  242.     if (cardPic != 0L) KillPicture(cardPic);
  243.     pagePic = (PicHandle)GetWRefCon(myWind);
  244.     if (pagePic != 0L) KillPicture(pagePic);
  245.     DisposeWindow(myWind);
  246.     returnValue( pXCmd, "0");
  247. }
  248.  
  249.  
  250.  
  251.  
  252. #include "hp2pict.inc.c"
  253.  
  254.  
  255.  
  256.  
  257.  
  258. void DrawHPWind(XCmdPtr pXCmd, int format)
  259. {
  260.     char         *c, *buf, *fname, *theWindowPtr, theResult[256];
  261.     Handle    hphand;
  262.     long        i, hplen;
  263.     WindowPtr myWind;    
  264.     PicHandle cardPic, pagePic;
  265.     int            err;
  266.     short        fref;
  267.     Rect        windrect, pagerect;
  268.     Boolean    alldone;  /* end of all plots -> multipage */
  269.     
  270.     
  271.     theWindowPtr = *(pXCmd->params[1]);
  272.     stringtonum(theWindowPtr,&myWind);
  273.     SetPort(myWind);
  274.     cardPic = GetWindowPic(myWind);
  275.     if (cardPic != 0L) KillPicture(cardPic);
  276.     cardPic = 0L;
  277.     pagePic = (PicHandle)GetWRefCon(myWind);
  278.     if (pagePic != 0L) KillPicture(pagePic);
  279.     pagePic = 0L;
  280.     
  281.     if (format == DFILE) {
  282.         /* --- read HP code from a file ---- */
  283.         fname = *(pXCmd->params[2]); 
  284.         if (fsopen( fname, 0, &fref) != 0) {
  285.             strcpy( theResult, "HPDraw, file not found: ");
  286.             strcat( theResult, fname);
  287.             returnValue( pXCmd, theResult);
  288.             return;
  289.             }
  290.         err = GetEOF( fref, &hplen);
  291.         hphand = NewHandle(hplen);
  292.         HLock(  hphand);
  293.         err = FSRead( fref, &hplen, *hphand);
  294.         err = FSClose( fref);
  295.         HUnlock( hphand);
  296.         SetHandleSize( hphand, hplen);
  297.         }
  298.     else {
  299.         hphand = pXCmd->params[2]; 
  300.         HandToHand( &hphand);
  301.         hplen = GetHandleSize(hphand);
  302.         }
  303.     
  304.     buf = *hphand;
  305.     /* fix any crud in container */
  306.     /* !! hi ascii is missed or dropped in C comparisons */
  307.     for (i = 0, c = buf; i<hplen; i++) {
  308.         if ( buf[i] == 3) *c++ = LBEND;
  309.         else if (buf[i] == LBEND | buf[i] >= 27) *c++ = buf[i]; 
  310.         }
  311.     *c = 0;
  312.     hplen = c - buf + 1;
  313.     SetHandleSize( hphand, hplen+10000); /* !! +10000 debug */
  314.     
  315.     /* windrect = HCard scaled size */
  316.     windrect = myWind->portRect; 
  317.     cardPic = hp2pict( false, &windrect, hphand, myWind,
  318.                                          format == DCOMM, &alldone, pXCmd);
  319.     
  320.     /* pagerect = lw scaled-landscape size */
  321.     SetRect( &pagerect, 0, 20, 730, 532); 
  322.     /* -- Note: commfetch is false 2nd time thru -- */
  323.     pagePic = hp2pict(  true, &pagerect, hphand, myWind,
  324.                                          false, &alldone, pXCmd);
  325.     
  326.     HUnlock( hphand);
  327.     pXCmd->returnValue = hphand; /* ? return for debugging */
  328.     /*
  329.     DisposHandle(hphand);
  330.     returnValue( pXCmd, "0");
  331.     */
  332.     if ((pagePic != 0L) 
  333.      & GetHandleSize((Handle)pagePic) > 0L )  
  334.         SetWRefCon(myWind,(long)pagePic);
  335.     else
  336.         SetWRefCon(myWind,0);
  337.     
  338.     if ((cardPic != 0L) 
  339.      & GetHandleSize((Handle)cardPic) > 0L ) {
  340.         SetWindowPic(myWind,cardPic);
  341.         BringToFront(myWind); 
  342.         }
  343.     else
  344.         SetWindowPic(myWind,NULL);
  345.  
  346. }
  347.  
  348.  
  349. void FileHPWind(XCmdPtr pXCmd)
  350. {
  351.     #define headsize  512
  352.     char    head[headsize];
  353.     int        n, err;
  354.     short    fref;
  355.     char     *fname, *theWindowPtr;
  356.     WindowPtr myWind;    
  357.     PicHandle pagePic;
  358.     
  359.     theWindowPtr = *(pXCmd->params[1]);
  360.     stringtonum(theWindowPtr,&myWind);
  361.     SetPort(myWind);
  362.     fname = *(pXCmd->params[2]);
  363.     pagePic = (PicHandle)GetWRefCon(myWind);
  364.     if (pagePic == 0L) pagePic = GetWindowPic(myWind);
  365.     if (pagePic != 0L) {
  366.         /* creator 'MDPL' == MacDraw II */
  367.         err = create( fname, 0, 'MDPL', 'PICT'); 
  368.         err = fsopen( fname, 0, &fref);
  369.         err = SetEOF( fref, 0);
  370.         for (n=0; n<headsize; n++) head[n] = 0;
  371.         n = headsize;
  372.         err = FSWrite( fref, &n, head);
  373.         n = GetHandleSize( (Handle) pagePic);
  374.         HLock( (Handle)pagePic);
  375.         err = FSWrite( fref, &n, *(Handle)pagePic);
  376.         HUnlock( (Handle)pagePic);
  377.         err = FSClose( fref);
  378.         }
  379. }
  380.  
  381.  
  382.  
  383.  
  384.  
  385. void ClipHPWind(XCmdPtr pXCmd)
  386. {
  387.     char     *theWindowPtr;
  388.     WindowPtr myWind;    
  389.     PicHandle cardPic;
  390.     
  391.     theWindowPtr = *(pXCmd->params[1]);
  392.     stringtonum(theWindowPtr,&myWind);
  393.     SetPort(myWind);
  394.     cardPic = GetWindowPic(myWind);
  395.     /* pagePic = (PicHandle)GetWRefCon(myWind); */
  396.     if (cardPic != 0L) {
  397.         ZeroScrap();
  398.         HLock((Handle)cardPic);
  399.         PutScrap(GetHandleSize((Handle)cardPic), 'PICT', *(Handle)cardPic);  
  400.         HUnlock((Handle)cardPic); 
  401.         }
  402. }
  403.  
  404.  
  405.      
  406. void PrintHPWind(XCmdPtr pXCmd)
  407. {
  408. #define rStopPrintDlog  102        /* this is HCard's PrintIdl dlog */
  409.     char                 *theWindowPtr;
  410.     WindowPtr     myWind;    
  411.     GrafPtr            oldPort;
  412.     TPPrPort        prPort;
  413.     TPrStatus      prStat;
  414.     Boolean            okay    = false;
  415.      THPrint            hprec;
  416.     PicHandle     pagePic;
  417.     DialogPtr        canDlog;
  418.     Str255            wname;
  419.             
  420.     
  421.     theWindowPtr = *(pXCmd->params[1]);
  422.     stringtonum(theWindowPtr,&myWind);
  423.     SetPort(myWind);
  424.     pagePic = (PicHandle)GetWRefCon(myWind);
  425.     if (pagePic == 0L) pagePic = GetWindowPic(myWind);
  426.     returnValue( pXCmd, "0");
  427.     if (pagePic != 0L) {        
  428.         GetPort(&oldPort);
  429.         PrOpen();  
  430.         if (PrError() == 0) {
  431.             hprec = (THPrint) NewHandle(sizeof(TPrint));
  432.             PrintDefault( hprec);
  433.             PrStlDialog( hprec);  /* ?? save hprec b/n calls here ? */
  434.             if (! PrJobDialog( hprec)) return; /* cancelled by user */
  435.          
  436.             SendHCMessage(pXCmd, "\pset cursor to watch"); 
  437.             GetWTitle(myWind, wname);
  438.             ParamText(wname,'','',''); 
  439.             canDlog = GetNewDialog(rStopPrintDlog, NULL, (WindowPtr)-1);
  440.             DrawDialog(canDlog);
  441.              
  442.             prPort = PrOpenDoc( hprec, NULL, NULL); 
  443.             SetPort( (GrafPtr)prPort); 
  444.             PrOpenPage(prPort,NULL);
  445.             DrawPicture( pagePic, &(**pagePic).picFrame);
  446.             PrClosePage( prPort);
  447.             PrCloseDoc( prPort);
  448.             if ( ((**hprec).prJob.bJDocLoop == bSpoolLoop)
  449.                      & (PrError() == 0) ) 
  450.                     PrPicFile(hprec, NULL,NULL,NULL, &prStat);
  451.             if (PrError() == 0) okay = true;
  452.             DisposHandle( (Handle)hprec);
  453.             DisposDialog( canDlog); 
  454.             }
  455.         PrClose();
  456.         SetPort(oldPort);
  457.         }
  458.     if (!okay) returnValue( pXCmd, "Printing error");
  459. } /* PrintWindow */
  460.  
  461.  
  462.  
  463.  
  464.  
  465.